{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import warnings\n",
    "\n",
    "if not sys.warnoptions:\n",
    "    warnings.simplefilter('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import pandas as pd\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from datetime import datetime\n",
    "from datetime import timedelta\n",
    "from tqdm import tqdm\n",
    "sns.set()\n",
    "tf.compat.v1.random.set_random_seed(1234)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Date</th>\n",
       "      <th>Open</th>\n",
       "      <th>High</th>\n",
       "      <th>Low</th>\n",
       "      <th>Close</th>\n",
       "      <th>Adj Close</th>\n",
       "      <th>Volume</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2016-11-02</td>\n",
       "      <td>778.200012</td>\n",
       "      <td>781.650024</td>\n",
       "      <td>763.450012</td>\n",
       "      <td>768.700012</td>\n",
       "      <td>768.700012</td>\n",
       "      <td>1872400</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2016-11-03</td>\n",
       "      <td>767.250000</td>\n",
       "      <td>769.950012</td>\n",
       "      <td>759.030029</td>\n",
       "      <td>762.130005</td>\n",
       "      <td>762.130005</td>\n",
       "      <td>1943200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2016-11-04</td>\n",
       "      <td>750.659973</td>\n",
       "      <td>770.359985</td>\n",
       "      <td>750.560974</td>\n",
       "      <td>762.020020</td>\n",
       "      <td>762.020020</td>\n",
       "      <td>2134800</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2016-11-07</td>\n",
       "      <td>774.500000</td>\n",
       "      <td>785.190002</td>\n",
       "      <td>772.549988</td>\n",
       "      <td>782.520020</td>\n",
       "      <td>782.520020</td>\n",
       "      <td>1585100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2016-11-08</td>\n",
       "      <td>783.400024</td>\n",
       "      <td>795.632996</td>\n",
       "      <td>780.190002</td>\n",
       "      <td>790.510010</td>\n",
       "      <td>790.510010</td>\n",
       "      <td>1350800</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         Date        Open        High         Low       Close   Adj Close  \\\n",
       "0  2016-11-02  778.200012  781.650024  763.450012  768.700012  768.700012   \n",
       "1  2016-11-03  767.250000  769.950012  759.030029  762.130005  762.130005   \n",
       "2  2016-11-04  750.659973  770.359985  750.560974  762.020020  762.020020   \n",
       "3  2016-11-07  774.500000  785.190002  772.549988  782.520020  782.520020   \n",
       "4  2016-11-08  783.400024  795.632996  780.190002  790.510010  790.510010   \n",
       "\n",
       "    Volume  \n",
       "0  1872400  \n",
       "1  1943200  \n",
       "2  2134800  \n",
       "3  1585100  \n",
       "4  1350800  "
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv('../dataset/GOOG-year.csv')\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.112708</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.090008</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.089628</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.160459</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.188066</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          0\n",
       "0  0.112708\n",
       "1  0.090008\n",
       "2  0.089628\n",
       "3  0.160459\n",
       "4  0.188066"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "minmax = MinMaxScaler().fit(df.iloc[:, 4:5].astype('float32')) # Close index\n",
    "df_log = minmax.transform(df.iloc[:, 4:5].astype('float32')) # Close index\n",
    "df_log = pd.DataFrame(df_log)\n",
    "df_log.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Split train and test\n",
    "\n",
    "I will cut the dataset to train and test datasets,\n",
    "\n",
    "1. Train dataset derived from starting timestamp until last 30 days\n",
    "2. Test dataset derived from last 30 days until end of the dataset\n",
    "\n",
    "So we will let the model do forecasting based on last 30 days, and we will going to repeat the experiment for 10 times. You can increase it locally if you want, and tuning parameters will help you by a lot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((252, 7), (222, 1), (30, 1))"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_size = 30\n",
    "simulation_size = 10\n",
    "\n",
    "df_train = df_log.iloc[:-test_size]\n",
    "df_test = df_log.iloc[-test_size:]\n",
    "df.shape, df_train.shape, df_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model:\n",
    "    def __init__(\n",
    "        self,\n",
    "        learning_rate,\n",
    "        num_layers,\n",
    "        size,\n",
    "        size_layer,\n",
    "        output_size,\n",
    "        forget_bias = 0.1,\n",
    "    ):\n",
    "        def lstm_cell(size_layer):\n",
    "            return tf.nn.rnn_cell.LSTMCell(size_layer, state_is_tuple = False)\n",
    "\n",
    "        backward_rnn_cells = tf.nn.rnn_cell.MultiRNNCell(\n",
    "            [lstm_cell(size_layer) for _ in range(num_layers)],\n",
    "            state_is_tuple = False,\n",
    "        )\n",
    "        forward_rnn_cells = tf.nn.rnn_cell.MultiRNNCell(\n",
    "            [lstm_cell(size_layer) for _ in range(num_layers)],\n",
    "            state_is_tuple = False,\n",
    "        )\n",
    "        self.X = tf.placeholder(tf.float32, (None, None, size))\n",
    "        self.Y = tf.placeholder(tf.float32, (None, output_size))\n",
    "        drop_backward = tf.contrib.rnn.DropoutWrapper(\n",
    "            backward_rnn_cells, output_keep_prob = forget_bias\n",
    "        )\n",
    "        forward_backward = tf.contrib.rnn.DropoutWrapper(\n",
    "            forward_rnn_cells, output_keep_prob = forget_bias\n",
    "        )\n",
    "        self.backward_hidden_layer = tf.placeholder(\n",
    "            tf.float32, shape = (None, num_layers * 2 * size_layer)\n",
    "        )\n",
    "        self.forward_hidden_layer = tf.placeholder(\n",
    "            tf.float32, shape = (None, num_layers * 2 * size_layer)\n",
    "        )\n",
    "        _, last_state = tf.nn.bidirectional_dynamic_rnn(\n",
    "            forward_backward,\n",
    "            drop_backward,\n",
    "            self.X,\n",
    "            initial_state_fw = self.forward_hidden_layer,\n",
    "            initial_state_bw = self.backward_hidden_layer,\n",
    "            dtype = tf.float32,\n",
    "        )\n",
    "        \n",
    "        with tf.variable_scope('decoder', reuse = False):\n",
    "            backward_rnn_cells_decoder = tf.nn.rnn_cell.MultiRNNCell(\n",
    "            [lstm_cell(size_layer) for _ in range(num_layers)],\n",
    "            state_is_tuple = False,\n",
    "            )\n",
    "            forward_rnn_cells_decoder = tf.nn.rnn_cell.MultiRNNCell(\n",
    "                [lstm_cell(size_layer) for _ in range(num_layers)],\n",
    "                state_is_tuple = False,\n",
    "            )\n",
    "            drop_backward_decoder = tf.contrib.rnn.DropoutWrapper(\n",
    "            backward_rnn_cells_decoder, output_keep_prob = forget_bias\n",
    "            )\n",
    "            forward_backward_decoder = tf.contrib.rnn.DropoutWrapper(\n",
    "                forward_rnn_cells_decoder, output_keep_prob = forget_bias\n",
    "            )\n",
    "            self.outputs, self.last_state = tf.nn.bidirectional_dynamic_rnn(\n",
    "                forward_backward_decoder, drop_backward_decoder, self.X, \n",
    "                initial_state_fw = last_state[0],\n",
    "                initial_state_bw = last_state[1],\n",
    "                dtype = tf.float32\n",
    "            )\n",
    "        self.outputs = tf.concat(self.outputs, 2)\n",
    "        self.logits = tf.layers.dense(self.outputs[-1], output_size)\n",
    "        self.cost = tf.reduce_mean(tf.square(self.Y - self.logits))\n",
    "        self.optimizer = tf.train.AdamOptimizer(learning_rate).minimize(\n",
    "            self.cost\n",
    "        )\n",
    "        \n",
    "def calculate_accuracy(real, predict):\n",
    "    real = np.array(real) + 1\n",
    "    predict = np.array(predict) + 1\n",
    "    percentage = 1 - np.sqrt(np.mean(np.square((real - predict) / real)))\n",
    "    return percentage * 100\n",
    "\n",
    "def anchor(signal, weight):\n",
    "    buffer = []\n",
    "    last = signal[0]\n",
    "    for i in signal:\n",
    "        smoothed_val = last * weight + (1 - weight) * i\n",
    "        buffer.append(smoothed_val)\n",
    "        last = smoothed_val\n",
    "    return buffer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_layers = 1\n",
    "size_layer = 128\n",
    "timestamp = 5\n",
    "epoch = 300\n",
    "dropout_rate = 0.8\n",
    "future_day = test_size\n",
    "learning_rate = 0.01"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def forecast():\n",
    "    tf.reset_default_graph()\n",
    "    modelnn = Model(\n",
    "        learning_rate, num_layers, df_log.shape[1], size_layer, df_log.shape[1], dropout_rate\n",
    "    )\n",
    "    sess = tf.InteractiveSession()\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    date_ori = pd.to_datetime(df.iloc[:, 0]).tolist()\n",
    "\n",
    "    pbar = tqdm(range(epoch), desc = 'train loop')\n",
    "    for i in pbar:\n",
    "        init_value_forward = np.zeros((1, num_layers * 2 * size_layer))\n",
    "        init_value_backward = np.zeros((1, num_layers * 2 * size_layer))\n",
    "        total_loss, total_acc = [], []\n",
    "        for k in range(0, df_train.shape[0] - 1, timestamp):\n",
    "            index = min(k + timestamp, df_train.shape[0] - 1)\n",
    "            batch_x = np.expand_dims(\n",
    "                df_train.iloc[k : index, :].values, axis = 0\n",
    "            )\n",
    "            batch_y = df_train.iloc[k + 1 : index + 1, :].values\n",
    "            logits, last_state, _, loss = sess.run(\n",
    "                [modelnn.logits, modelnn.last_state, modelnn.optimizer, modelnn.cost],\n",
    "                feed_dict = {\n",
    "                    modelnn.X: batch_x,\n",
    "                    modelnn.Y: batch_y,\n",
    "                    modelnn.backward_hidden_layer: init_value_backward,\n",
    "                    modelnn.forward_hidden_layer: init_value_forward,\n",
    "                },\n",
    "            )        \n",
    "            init_value_forward = last_state[0]\n",
    "            init_value_backward = last_state[1]\n",
    "            total_loss.append(loss)\n",
    "            total_acc.append(calculate_accuracy(batch_y[:, 0], logits[:, 0]))\n",
    "        pbar.set_postfix(cost = np.mean(total_loss), acc = np.mean(total_acc))\n",
    "    \n",
    "    future_day = test_size\n",
    "\n",
    "    output_predict = np.zeros((df_train.shape[0] + future_day, df_train.shape[1]))\n",
    "    output_predict[0] = df_train.iloc[0]\n",
    "    upper_b = (df_train.shape[0] // timestamp) * timestamp\n",
    "    init_value_forward = np.zeros((1, num_layers * 2 * size_layer))\n",
    "    init_value_backward = np.zeros((1, num_layers * 2 * size_layer))\n",
    "\n",
    "    for k in range(0, (df_train.shape[0] // timestamp) * timestamp, timestamp):\n",
    "        out_logits, last_state = sess.run(\n",
    "            [modelnn.logits, modelnn.last_state],\n",
    "            feed_dict = {\n",
    "                modelnn.X: np.expand_dims(\n",
    "                    df_train.iloc[k : k + timestamp], axis = 0\n",
    "                ),\n",
    "                modelnn.backward_hidden_layer: init_value_backward,\n",
    "                modelnn.forward_hidden_layer: init_value_forward,\n",
    "            },\n",
    "        )\n",
    "        init_value_forward = last_state[0]\n",
    "        init_value_backward = last_state[1]\n",
    "        output_predict[k + 1 : k + timestamp + 1] = out_logits\n",
    "\n",
    "    if upper_b != df_train.shape[0]:\n",
    "        out_logits, last_state = sess.run(\n",
    "            [modelnn.logits, modelnn.last_state],\n",
    "            feed_dict = {\n",
    "                modelnn.X: np.expand_dims(df_train.iloc[upper_b:], axis = 0),\n",
    "                modelnn.backward_hidden_layer: init_value_backward,\n",
    "                modelnn.forward_hidden_layer: init_value_forward,\n",
    "            },\n",
    "        )\n",
    "        output_predict[upper_b + 1 : df_train.shape[0] + 1] = out_logits\n",
    "        future_day -= 1\n",
    "        date_ori.append(date_ori[-1] + timedelta(days = 1))\n",
    "\n",
    "    init_value_forward = last_state[0]\n",
    "    init_value_backward = last_state[1]\n",
    "    \n",
    "    for i in range(future_day):\n",
    "        o = output_predict[-future_day - timestamp + i:-future_day + i]\n",
    "        out_logits, last_state = sess.run(\n",
    "            [modelnn.logits, modelnn.last_state],\n",
    "            feed_dict = {\n",
    "                modelnn.X: np.expand_dims(o, axis = 0),\n",
    "                modelnn.backward_hidden_layer: init_value_backward,\n",
    "                modelnn.forward_hidden_layer: init_value_forward,\n",
    "            },\n",
    "        )\n",
    "        init_value_forward = last_state[0]\n",
    "        init_value_backward = last_state[1]\n",
    "        output_predict[-future_day + i] = out_logits[-1]\n",
    "        date_ori.append(date_ori[-1] + timedelta(days = 1))\n",
    "    \n",
    "    output_predict = minmax.inverse_transform(output_predict)\n",
    "    deep_future = anchor(output_predict[:, 0], 0.3)\n",
    "    \n",
    "    return deep_future[-test_size:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "W0813 22:30:03.664880 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6c6a29f9e8>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 22:30:03.666436 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6c6a0dba58>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 22:30:03.827417 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6c6a0db5f8>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 22:30:03.828239 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6c6a0dbe48>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "W0813 22:30:03.988492 140106178451264 deprecation.py:323] From <ipython-input-10-79385dfa86b9>:67: dense (from tensorflow.python.layers.core) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use keras.layers.dense instead.\n",
      "train loop: 100%|██████████| 300/300 [02:29<00:00,  2.03it/s, acc=96.4, cost=0.00318] \n",
      "W0813 22:32:35.430384 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6c68a2de10>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 22:32:35.431268 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6c689d96a0>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 22:32:35.592414 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6c689d91d0>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 22:32:35.593283 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6c680bc630>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [02:30<00:00,  2.00it/s, acc=98.1, cost=0.000912]\n",
      "W0813 22:35:08.073616 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6c68a6df28>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 22:35:08.074523 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6c40475208>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 22:35:08.237059 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6bbbf9afd0>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 22:35:08.237945 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6bbbf56fd0>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 3\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [02:31<00:00,  1.99it/s, acc=98.2, cost=0.000814]\n",
      "W0813 22:37:40.822348 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6c40403080>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 22:37:40.823194 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6bba08cac8>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 22:37:40.984025 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6bb9234278>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 22:37:40.984853 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6bb90d59e8>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [02:31<00:00,  1.98it/s, acc=98.2, cost=0.000732]\n",
      "W0813 22:40:14.461846 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6bb230a7f0>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 22:40:14.462596 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6bb31e4588>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 22:40:14.624744 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6bb2361198>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 22:40:14.625597 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6bb223d5c0>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [02:28<00:00,  2.04it/s, acc=98.6, cost=0.000437]\n",
      "W0813 22:42:44.319911 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6baf458dd8>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 22:42:44.320685 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6bb0355400>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 22:42:44.481708 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6baf534d30>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 22:42:44.482524 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6baf3f2c88>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 6\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [02:30<00:00,  2.00it/s, acc=98.8, cost=0.000304]\n",
      "W0813 22:45:16.281273 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6bb04d4240>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 22:45:16.282183 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6bad522c18>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 22:45:16.443265 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6bad522940>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 22:45:16.444107 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6bac5314e0>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 7\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [02:31<00:00,  1.99it/s, acc=98.5, cost=0.000517]\n",
      "W0813 22:47:49.574930 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6ba974ef28>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 22:47:49.575763 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6baa69bc18>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 22:47:49.735839 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6ba9794a20>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 22:47:49.736666 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6ba7e914a8>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 8\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [02:31<00:00,  1.99it/s, acc=96.9, cost=0.00272] \n",
      "W0813 22:50:22.981087 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6ba69149b0>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 22:50:22.982089 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6ba7828080>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 22:50:23.141866 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6ba69434e0>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 22:50:23.142687 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6ba68067b8>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 9\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [02:31<00:00,  1.99it/s, acc=98.2, cost=0.000705]\n",
      "W0813 22:52:55.940449 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6ba3aacbe0>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 22:52:55.941309 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6ba49a4080>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 22:52:56.101360 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6ba21a14e0>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 22:52:56.102182 140106178451264 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6ba39be898>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 10\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [02:27<00:00,  2.03it/s, acc=98.6, cost=0.000453]\n"
     ]
    }
   ],
   "source": [
    "results = []\n",
    "for i in range(simulation_size):\n",
    "    print('simulation %d'%(i + 1))\n",
    "    results.append(forecast())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "accuracies = [calculate_accuracy(df['Close'].iloc[-test_size:].values, r) for r in results]\n",
    "\n",
    "plt.figure(figsize = (15, 5))\n",
    "for no, r in enumerate(results):\n",
    "    plt.plot(r, label = 'forecast %d'%(no + 1))\n",
    "plt.plot(df['Close'].iloc[-test_size:].values, label = 'true trend', c = 'black')\n",
    "plt.legend()\n",
    "plt.title('average accuracy: %.4f'%(np.mean(accuracies)))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
